package com.mlnx.yingbaisui.device.utils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class StringUtils {
    /**
     * 16进制转byte流
     * @param str
     * @return
     */
    public static byte[] getByteByString(String str) {
        str = str.toLowerCase();
        char[] hexChars = str.toCharArray();
        int len = str.length()/2;
        byte[] bytes = new byte[len];
        for (int i = 0; i < len; i++) {
            int pos = i * 2;
            bytes[i] = (byte)(charToByte(hexChars[pos]) << 4 | (byte)charToByte(hexChars[pos + 1]));
        }
        return bytes;
    }

    /**
     * char转byte
     * @param c
     * @return
     */
    public static byte charToByte(char c) {
        return (byte)"0123456789abcdef".indexOf(c);
    }

    /**
     * byte转16进制 String
     * @param buf
     * @param len
     * @return
     */
    public static String byteToHexString(byte[] buf, int len) {
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < len; i++) {
            stringBuffer.append(String.format("%02x", buf[i]));
        }
        return stringBuffer.toString();
    }

    //==================================基本函数=============================================

    /**
     * 【功能：帧尾两个字节求和使用的 】
     * 【输入】：十六进制字符串
     * 【输出】：四位长度，十六进制，字符串，大端模式
     * @param str
     * @return
     */
    public static String addLast2Hex(String str) {
        int sum = 0;
        String s;
        for (int i = 0; i < str.length(); i++) {
            s = str.substring(i, i + 1);
            if (i % 2 == 0) {
                sum += Integer.parseInt(s, 16) * 16;
            }
            else {
                sum += Integer.parseInt(s, 16);
            }
        }
        return toHexStr(sum / 256) + toHexStr(sum % 256);
    }

    /**
     * 【功能：传入数字返回十六进制字符串】
     * 【输入】：数字，小于256
     * 【输出】：两位长度，十六进制，字符串
     * @param i
     * @return
     */
    public static String toHexStr(int i) {
        if (i < 16) {
            return "0" + Integer.toHexString(i);
        }
        else{
            return Integer.toHexString(i);
        }
    }

    /**
     * 【功能：传入字符串返回十六进制字符串】
     * 【输入】：字符串
     * 【输出】：两位长度，十六进制，字符
     * @param str
     * @return
     */
    public static String toHexStr(String str) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < str.length(); i ++) {
            sb.append(toHexStr(str.charAt(i)));
        }
        return sb.toString();
    }

    public static String toHexStr(char str) {
        int i = (int)str;
        if (i < 16) {
            return "0" + Integer.toHexString(i);
        }
        else{
            return Integer.toHexString(i);
        }
    }

    /**
     *【功能：传入十六进制字符串返回字符】
     * 【输入】：两位长度，十六进制，字符
     * 【输出】：字符
     * @param str
     * @return
     */
    public static String toStr(String str) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < str.length() / 2; i++) {
            sb.append(toChar(str.substring(i * 2, i * 2 + 2)));
        }
        return sb.toString();
    }

    public static char toChar(String str) {
        return (char)Integer.parseInt(str,16);
    }

    /**
     * 【功能：解析命令】
     * @return
     */
    public static List<Object> unpackCheck(String str) {
        List<Object> r = new ArrayList<>();
        String comm = str.substring(0 , 4);
        if (comm.equals("55aa")) {
            try {
                String commandNumber = str.substring(4 , 6);
                int dataLength = Integer.parseInt(str.substring(6 , 8), 16);
                String data = str.substring(8 , 8 + dataLength * 2);
                String restLast = str.substring(8 + dataLength * 2);
                HashMap rMap = new HashMap();
                rMap.put("comm",comm);
                rMap.put("commandNumber", commandNumber);
                rMap.put("dataLength", dataLength);
                rMap.put("data", data);
                r.add(rMap);
                if (restLast.length() > 4) {
                    List<Object> list = unpackCheck(restLast.substring(4));
                    if (!list.isEmpty()) {
                        r.addAll(list);
                    }
                }
            }
            catch (Exception e) {
                System.out.println("解析命令 存在数据段不完整,请重新输入数据");
                r = new ArrayList<>();
            }
        }
        else {
            System.out.println("解析命令 ERROR (收到的不是55aa指令，无法解析)");
        }
        return r;
    }

    /**
     * 将汉字转换车16进制字符串
     * @param str
     * @return st
     */
    public static String enUnicode(String str) {// 将汉字转换为16进制数
        String st = "";
        try {
            //这里要非常的注意,在将字符串转换成字节数组的时候一定要明确是什么格式的,这里使用的是gb2312格式的,还有utf-8,ISO-8859-1等格式
            byte[] by = str.getBytes("gb2312");
            for (int i = 0; i < by.length; i++) {
                String strs = Integer.toHexString(by[i]);
                if (strs.length() > 2) {
                    strs = strs.substring(strs.length() - 2);
                }
                st += strs;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return st;
    }
}
